/**
 * 平台兼容性检查工具
 */
export default class PlatformUtils {
  
  /**
   * 获取当前平台
   * @returns {string} 平台名称
   */
  static getPlatform() {
    const systemInfo = uni.getSystemInfoSync()
    return systemInfo.platform
  }
  
  /**
   * 检查是否为移动端
   * @returns {boolean} 是否为移动端
   */
  static isMobile() {
    const platform = this.getPlatform()
    return platform === 'android' || platform === 'ios'
  }
  
  /**
   * 检查是否为H5平台
   * @returns {boolean} 是否为H5平台
   */
  static isH5() {
    const platform = this.getPlatform()
    return platform === 'web'
  }
  
  /**
   * 检查是否为开发工具
   * @returns {boolean} 是否为开发工具
   */
  static isDevTools() {
    const platform = this.getPlatform()
    return platform === 'devtools'
  }
  
  /**
   * 检查是否支持相册保存
   * @returns {boolean} 是否支持相册保存
   */
  static supportsPhotoAlbum() {
    return this.isMobile()
  }
  
  /**
   * 检查是否支持文件下载
   * @returns {boolean} 是否支持文件下载
   */
  static supportsDownload() {
    return this.isH5()
  }
  
  /**
   * 检查是否支持本地存储
   * @returns {boolean} 是否支持本地存储
   */
  static supportsLocalStorage() {
    return true // uni-app在所有平台都支持本地存储
  }
  
  /**
   * 检查是否支持图片预览
   * @returns {boolean} 是否支持图片预览
   */
  static supportsImagePreview() {
    return true // 大多数平台都支持图片预览
  }
  
  /**
   * 获取平台特定的保存方法
   * @returns {string} 保存方法名称
   */
  static getSaveMethod() {
    if (this.supportsPhotoAlbum()) {
      return 'photoAlbum'
    } else if (this.supportsDownload()) {
      return 'download'
    } else if (this.isDevTools()) {
      return 'preview'
    } else {
      return 'localStorage'
    }
  }
  
  /**
   * 获取平台特定的保存提示信息
   * @returns {string} 提示信息
   */
  static getSaveMessage() {
    if (this.isDevTools()) {
      return '在开发工具中，图片将使用预览方式显示，请手动保存'
    } else if (this.supportsPhotoAlbum()) {
      return '图片将保存到相册'
    } else if (this.supportsDownload()) {
      return '图片将自动下载'
    } else {
      return '图片将保存到本地存储'
    }
  }
  
  /**
   * 显示平台特定的提示信息
   * @param {string} message 提示信息
   */
  static showPlatformMessage(message) {
    const platform = this.getPlatform()
    const platformName = {
      'android': 'Android',
      'ios': 'iOS',
      'web': 'H5',
      'devtools': '开发工具'
    }[platform] || platform
    
    uni.showToast({
      title: `${platformName}: ${message}`,
      icon: 'none',
      duration: 3000
    })
  }
  
  /**
   * 获取当前环境的保存建议
   * @returns {object} 保存建议
   */
  static getSaveSuggestion() {
    const platform = this.getPlatform()
    
    switch (platform) {
      case 'android':
      case 'ios':
        return {
          method: 'photoAlbum',
          message: '图片将保存到手机相册',
          supported: true
        }
      case 'web':
        return {
          method: 'download',
          message: '图片将自动下载到浏览器默认下载目录',
          supported: true
        }
      case 'devtools':
        return {
          method: 'preview',
          message: '图片将使用预览方式显示，请手动保存',
          supported: false
        }
      default:
        return {
          method: 'preview',
          message: '当前环境不支持自动保存，将使用预览方式',
          supported: false
        }
    }
  }
  
  /**
   * 平台工具类
   */
  static getPlatformInfo() {
    const systemInfo = uni.getSystemInfoSync()
    return {
      platform: systemInfo.platform,
      system: systemInfo.system,
      version: systemInfo.version,
      SDKVersion: systemInfo.SDKVersion
    }
  }
  
  /**
   * 验证图片路径
   * @param {string} imagePath 图片路径
   * @returns {object} 验证结果
   */
  static validateImagePath(imagePath) {
    const result = {
      isValid: false,
      error: null,
      normalizedPath: null,
      pathVariations: []
    }
    
    try {
      // 基本验证
      if (!imagePath || typeof imagePath !== 'string') {
        result.error = '图片路径为空或类型错误'
        return result
      }
      
      if (imagePath.trim() === '') {
        result.error = '图片路径为空字符串'
        return result
      }
      
      console.log('原始图片路径:', imagePath)
      
      // 生成多种路径变体以适配不同平台
      const pathVariations = [imagePath]
      const platform = uni.getSystemInfoSync().platform
      
      // 处理uni-app临时文件路径
      if (imagePath.includes('uni-app://')) {
        pathVariations.push(imagePath.replace('uni-app://', 'file://'))
        pathVariations.push(imagePath.replace('uni-app://', ''))
      }
      
      // 处理file://前缀
      if (imagePath.startsWith('file://')) {
        pathVariations.push(imagePath.replace('file://', ''))
        pathVariations.push(imagePath.replace('file://', '/'))
      }
      
      // 处理相对路径
      if (imagePath.startsWith('/')) {
        pathVariations.push('file://' + imagePath)
        pathVariations.push(imagePath.substring(1))
      }
      
      // 平台特定处理
      if (platform === 'android') {
        // Android平台特殊处理
        if (imagePath.startsWith('/storage/') || imagePath.startsWith('/data/')) {
          pathVariations.push('file://' + imagePath)
          pathVariations.push(imagePath)
        }
        // 处理临时文件路径
        if (imagePath.includes('tmp/') || imagePath.includes('cache/')) {
          pathVariations.push(imagePath)
          pathVariations.push('file://' + imagePath)
        }
      } else if (platform === 'ios') {
        // iOS平台特殊处理
        if (imagePath.startsWith('/var/') || imagePath.startsWith('/tmp/')) {
          pathVariations.push('file://' + imagePath)
          pathVariations.push(imagePath)
        }
      }
      
      // 去重并过滤空路径
      const uniquePaths = [...new Set(pathVariations)].filter(path => path && path.trim() !== '')
      
      console.log('生成的路径变体:', uniquePaths)
      
      result.isValid = true
      result.normalizedPath = uniquePaths[0] // 使用第一个作为默认
      result.pathVariations = uniquePaths
      
    } catch (error) {
      result.error = '路径验证过程中发生错误: ' + error.message
    }
    
    return result
  }
  
  /**
   * 测试图片路径是否可访问
   * @param {string} imagePath 图片路径
   * @returns {Promise<object>} 测试结果
   */
  static async testImagePath(imagePath) {
    return new Promise((resolve) => {
      const result = {
        accessible: false,
        error: null,
        imageInfo: null,
        successfulPath: null
      }
      
      // 首先验证路径格式
      const validation = this.validateImagePath(imagePath)
      if (!validation.isValid) {
        result.error = validation.error
        resolve(result)
        return
      }
      
      // 获取所有路径变体
      const pathVariations = validation.pathVariations || [validation.normalizedPath || imagePath]
      console.log('将尝试以下路径:', pathVariations)
      
      let currentIndex = 0
      
      const tryNextPath = () => {
        if (currentIndex >= pathVariations.length) {
          // 所有路径都尝试失败
          result.error = `所有路径都无法访问: ${pathVariations.join(', ')}`
          resolve(result)
          return
        }
        
        const currentPath = pathVariations[currentIndex]
        console.log(`尝试路径 ${currentIndex + 1}/${pathVariations.length}:`, currentPath)
        
        uni.getImageInfo({
          src: currentPath,
          success: (res) => {
            console.log(`路径 ${currentPath} 访问成功:`, res)
            result.accessible = true
            result.imageInfo = res
            result.successfulPath = currentPath
            resolve(result)
          },
          fail: (err) => {
            console.log(`路径 ${currentPath} 访问失败:`, err)
            currentIndex++
            // 延迟一点时间再尝试下一个路径
            setTimeout(tryNextPath, 100)
          }
        })
      }
      
      // 开始尝试第一个路径
      tryNextPath()
    })
  }
  
  /**
   * 获取支持的图片格式
   * @returns {array} 支持的图片格式列表
   */
  static getSupportedImageFormats() {
    return ['jpg', 'jpeg', 'png', 'gif', 'webp']
  }
  
  /**
   * 检查图片格式是否支持
   * @param {string} imagePath 图片路径
   * @returns {boolean} 是否支持
   */
  static isImageFormatSupported(imagePath) {
    if (!imagePath) return false
    
    const supportedFormats = this.getSupportedImageFormats()
    const extension = imagePath.split('.').pop()?.toLowerCase()
    
    return supportedFormats.includes(extension)
  }
  
  /**
   * 获取图片文件大小限制
   * @returns {number} 文件大小限制（字节）
   */
  static getImageSizeLimit() {
    const platform = uni.getSystemInfoSync().platform
    
    switch (platform) {
      case 'android':
        return 10 * 1024 * 1024 // 10MB
      case 'ios':
        return 20 * 1024 * 1024 // 20MB
      default:
        return 5 * 1024 * 1024 // 5MB
    }
  }
  
  /**
   * 处理Android平台的文件路径
   * @param {string} filePath 原始文件路径
   * @returns {string} 处理后的文件路径
   */
  static normalizeAndroidFilePath(filePath) {
    if (!filePath || typeof filePath !== 'string') {
      return filePath
    }
    
    const platform = uni.getSystemInfoSync().platform
    if (platform !== 'android') {
      return filePath
    }
    
    console.log('处理Android文件路径:', filePath)
    
    // 处理uni-app临时文件路径
    if (filePath.includes('uniapp_temp_') || filePath.includes('_doc/')) {
      // 对于uni-app临时文件，直接使用原路径
      console.log('uni-app临时文件，使用原路径:', filePath)
      return filePath
    }
    
    // 移除可能的file://前缀
    let normalizedPath = filePath
    if (normalizedPath.startsWith('file://')) {
      normalizedPath = normalizedPath.replace('file://', '')
    }
    
    // 确保路径以/开头
    if (!normalizedPath.startsWith('/')) {
      normalizedPath = '/' + normalizedPath
    }
    
    // 处理临时文件路径
    if (normalizedPath.includes('tmp/') || normalizedPath.includes('cache/')) {
      // 对于临时文件，保持原样
      console.log('临时文件路径，保持原样:', normalizedPath)
    } else {
      // 对于其他路径，尝试添加file://前缀
      normalizedPath = 'file://' + normalizedPath
    }
    
    console.log('处理后的Android文件路径:', normalizedPath)
    return normalizedPath
  }
  
  /**
   * 验证文件路径是否可用于保存
   * @param {string} filePath 文件路径
   * @returns {object} 验证结果
   */
  static validateSaveFilePath(filePath) {
    const result = {
      isValid: false,
      error: null,
      normalizedPath: null
    }
    
    try {
      // 基本验证
      if (!filePath || typeof filePath !== 'string') {
        result.error = '文件路径为空或类型错误'
        return result
      }
      
      if (filePath.trim() === '') {
        result.error = '文件路径为空字符串'
        return result
      }
      
      // 平台特定处理
      const platform = uni.getSystemInfoSync().platform
      let normalizedPath = filePath
      
      if (platform === 'android') {
        normalizedPath = this.normalizeAndroidFilePath(filePath)
      }
      
      result.isValid = true
      result.normalizedPath = normalizedPath
      
    } catch (error) {
      result.error = '路径验证过程中发生错误: ' + error.message
    }
    
    return result
  }
} 